The present invention relates to a computer system executing foreign code and more particularly to a computer system and method for efficient handling of exceptions that arise when executing binary translated code.
Complex computer software applications are often written for execution on a specific type of computer architecture. However, when software applications are built from a variety of sources using different design tools, the task of porting the software application to a new platform, based on a different architectural design, is very complex and time consuming. Several techniques have been developed to facilitate the porting of code from a foreign architecture to a different, native, architecture. For example, when source code is available, the foreign code could be recompiled to run under the host architecture. Unfortunately, source code is often unavailable. Alternatively, if only the object or binary code is available, a software program at run-time could interpret the compiled foreign code. The interpreter is written with an understanding of the nuances between the foreign and the host architectures but, unfortunately, software interpretation is an inherently slow process. Accordingly, except in applications where significant performance degradation can be tolerated, software interpreters are unacceptable.
Another technique is to use a hardware emulator to interpret the foreign code. The emulator uses a micromachine that includes specialized hardware to increase the speed of the translation process. Unfortunately, because emulators do not have a microcoded hardware layer underlying the visible machine architecture, they are generally insufficient when the host architecture is based on a reduced instruction set code (RISC).
Yet another technique is to use binary translation to generate a sequence of instructions that perform the same functions and achieve the same behavior as on the foreign platform. When the binary translated code is executed on the host platform, the state information of the foreign architecture is maintained in the registers of the host platform. Although binary translation is an efficient mechanism for executing foreign code in a host environment, it is accepted in the field of computer programming that software programs may include logic errors and run-time errors. Logic errors and run-time errors come to light when the program is executing making it difficult to accurately execute the foreign code in the host environment. Logic errors may cause the program to operate incorrectly or provide incorrect results. Run-time errors often occur when the program is running and a condition is encountered that violates a mathematical or logical rule or attempts to access invalid memory or data. While most programmers extensively test the program before releasing it for use to identify and correct logic errors, it is common practice to provide a plurality of exception handlers to sort out run-time errors (often referred to as exceptions). An exception is a problem or a change in conditions that causes the processor or computer system to stop or suspend execution of the program and respond to the problem in a separate routine, which is often referred to as an exception handler.
An exception is similar to an interrupt in that it refers the processor to a separate set of instructions. In essence, the exception handler initiates a process designed to provide a solution to the problem or to the change in conditions whenever encountered during the execution of the program. Exceptions are synchronous events that are generated in response to certain conditions detected during the execution of an instruction. The exception causes the processor to suspend execution of the program and invoke the operation of another set of programming instructions.
Common exceptions arise, by way of example, when the denominator is zero and a divide instruction is executed; when an overflow occurs as the result of an arithmetic operation; when an invalid processor instruction is encountered; when a page fault occurs or when an illegal operation is detected. Unlike an interrupt, the exception is always reproducible by re-executing the program with the original data that caused the exception. By way of example, a page fault is a typical exception during any program execution, because operating system could swap some pages from memory to external hard disk, and if any memory access operation in user's program touches such swapped page there will be an exception. As the exception occurs, the exception handler in the operating system will load the needed page from disk into the memory and then re-execute faulted user's instruction. Accordingly, the host environment must be capable of responding to these exceptions in a real time environment. Another problem with exception handling arises when instructions are executed out of sequential order in the host environment. When this happens, certain instructions may commit their results and modify registers or memory locations before (or after) the exception is reported to the exception handler. Thus, when the exception handler is invoked in the host environment, the status of the memory, as well as the data in the registers may not accurately reflect the state of the computer system. Accordingly, the host environment must be capable of supporting precise exceptions. Precise exceptions are necessary if a subsequent instruction has committed its result before the exception occurs. When instructions are executed out of sequential order, the status may have changed such that it is not possible to subsequently re-create the state of the system as it existed immediately prior to the exception. To illustrate, when a program executes an ordered set of foreign instructions: i1, i2, . . . in, ie, im, . . . , it is possible that each of these instructions will produce certain side effects that will change the state of various computer resources. Side effects may change the content of registers and memory or set various logical flags in the status register. The exception generated by instruction “ie” is a “precise” exception if instruction “im” has not yet been executed and all prior instructions preceding instruction “ie” have executed and committed their results. A “precise” exception means that instruction “im” has not yet been executed and all prior instructions preceding instruction “ie” have executed and committed their results. When a precise exception occurs, instruction “ie” can be restarted if the instruction pointer (IP) register is preserved. However, if any of the instructions following instruction “ie” in the ordered set, has committed its results then the exception is called imprecise because the state of the computer will have been altered and execution beginning with instruction “ie” cannot be restarted after processing the exception.
The ability to preserve the behavior of the foreign code, including precise exceptions, in binary translated code in a host environment capable of executing instructions in parallel is called “precise exception maintenance.” If the host environment is capable of executing instructions in parallel, the exception handler must be able to solve the cause of the exception without using possibly corrupted data and system status information.
Different approaches to maintaining precise exceptions are known in the art. For example, some systems may create a “check point” in the code at which point the normal operation of the system is suspended to save the current state. However, suspending the execution is inherently undesirable if the system is to operate without degrading performance compared to the foreign architecture. In alternative approaches, some systems may employ “speculative execution” where all branches of a code sequence are executed and stored for later use. However, this approach results in an inefficient utilization of system resources.
Clearly what is needed is a method and apparatus for preserving the behavior of the foreign code, including precise exceptions, in binary translated code in a host environment capable of executing instructions in parallel. Further, what is needed a method and an apparatus that automatically determines the cause of the exception and provides an accurate solution to the problem or change in conditions even if the instruction sequence is executed in non-sequential order. Further still, it is desirable to support precise exceptions in a host architecture in a manner that correctly emulates a foreign architecture.